home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 14 / CU Amiga Magazine's Super CD-ROM 14 (1997)(EMAP Images)(GB)(Track 1 of 3)[!][issue 1997-09].iso / CUCD / Programming / Mesa-2.2 / demos / stex3d.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-04  |  15.6 KB  |  559 lines
  1. /*----------------------------- 
  2.  * stex3d.c GL example of the mesa 3d-texture extention to simulate procedural
  3.  *            texturing, it uses a perlin noise and turbulence functions.
  4.  * 
  5.  * Author:   Daniel Barrero
  6.  *           barrero@irit.fr
  7.  *           dbarrero@pegasus.uniandes.edu.co
  8.  *      
  9.  * cc stex3d.c -o stex3d -lMesaGLU -lMesaGL -lMesatk -lX11 -lXext -lm 
  10.  *
  11.  *---------------------------- */
  12.  
  13. #include <string.h>
  14. #include <stdio.h>
  15. #include <stdlib.h>
  16. #include <math.h>
  17. #include <GL/gl.h>
  18. /*#include "gltkmesa.h"*/
  19. #include "gltk.h"
  20. /* function declarations */
  21. #ifndef M_PI
  22. #define M_PI            3.14159265358979323846
  23. #endif
  24.  
  25. void init(void),
  26.      printHelp(void),
  27.      create3Dtexture(void),
  28.      setDefaults(void),
  29.      drawScene(void),
  30.      resize(int w, int h),
  31.      buildFigure(void),
  32.      initNoise(void);
  33. float turbulence(float point[3], float lofreq, float hifreq);
  34.  
  35. int isExtSupported(char *ext);
  36. GLenum keyHandler(int key, GLenum mask),
  37.        parseCmdLine(int argc, char **argv);
  38. float noise3(float vec[3]);
  39.       
  40. /* global variables */
  41. GLenum rgb, doubleBuffer, directRender, windType; /* visualization state*/
  42. float tex_width,tex_height,tex_depth;        /* texture volume dimensions  */
  43. unsigned char *voxels;                       /* texture data ptr */
  44. int angx,angy,angz;
  45. GLuint figure;
  46.  
  47. /*function definitions */
  48. void main(int argc, char **argv)
  49. {
  50.  
  51.  if (parseCmdLine(argc, argv) == GL_FALSE) {
  52.     tkQuit();
  53.  }
  54.  
  55.  tkInitPosition(0, 0, 400, 400);
  56.  windType = (rgb) ? TK_RGB : TK_INDEX;
  57.  windType |= (doubleBuffer) ? TK_DOUBLE : TK_SINGLE;
  58.  windType |= (directRender) ? TK_DIRECT : TK_INDIRECT;
  59.  windType |= TK_DEPTH;
  60.  tkInitDisplayMode(windType);
  61.  
  62.  if (tkInitWindow("stex3d") == GL_FALSE) {
  63.      tkQuit();
  64.  }
  65.  /* init all */
  66.  init();
  67.  
  68.  tkExposeFunc(resize);
  69.  tkReshapeFunc(resize);
  70.  tkKeyDownFunc(keyHandler);
  71.  tkDisplayFunc(drawScene);
  72.  tkExec();
  73. }
  74.  
  75. void init()
  76. { 
  77.  /* init light */
  78.  GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
  79.  GLfloat mat_shininess[] = { 25.0 };
  80.  GLfloat gray[] = { 0.6, 0.6, 0.6, 0.0 };
  81.  GLfloat white[] = { 1.0, 1.0, 1.0, 0.0 };
  82.  GLfloat light_position[] = { 0.0, 1.0, 1.0, 0.0 };
  83.  
  84.  glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
  85.  glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
  86.  glLightfv(GL_LIGHT1, GL_POSITION, light_position);
  87.  glLightfv(GL_LIGHT1, GL_AMBIENT, gray);
  88.  glLightfv(GL_LIGHT1, GL_DIFFUSE, white);
  89.  glLightfv(GL_LIGHT1, GL_SPECULAR, white);
  90.  glColorMaterial(GL_FRONT, GL_DIFFUSE);
  91.  glEnable(GL_COLOR_MATERIAL);
  92.  glEnable(GL_LIGHTING);
  93.  glEnable(GL_LIGHT1);
  94.  
  95.  /* create torus for texturing */
  96.  figure=glGenLists(1); 
  97.  buildFigure();
  98. /* tkSolidTorus(figure,0.3,1.2);*/
  99.  
  100.  /* start the noise function variables */
  101.  initNoise();
  102.  
  103.  /* see if the texture 3d extention is supported */
  104.  if (!isExtSupported("GL_EXT_texture3D")) {
  105.    printf("Sorry this GL implementation (%s) does not support 3d texture extentions\n",
  106.         (char *)(glGetString(GL_RENDERER)));
  107. /*   tkQuit();*/
  108.  }
  109.  
  110.  /* if texture is supported then generate the texture */
  111.  create3Dtexture(); 
  112.  
  113.  glEnable(GL_TEXTURE_3D_EXT); 
  114.  /*
  115.  glBlendFunc(GL_SRC_COLOR, GL_SRC_ALPHA);
  116.  glEnable(GL_BLEND); 
  117.  */
  118.  glEnable(GL_DEPTH_TEST);
  119.  
  120.  glShadeModel(GL_FLAT);
  121.  glColor3f(0.6,0.7,0.8);
  122. }
  123.  
  124. void buildFigure(void)
  125. {   GLint i, j;
  126.     float theta1, phi1, theta2, phi2, rings, sides;
  127.     float v0[03], v1[3], v2[3], v3[3];
  128.     float t0[03], t1[3], t2[3], t3[3];
  129.     float n0[3], n1[3], n2[3], n3[3];
  130.     float innerRadius=0.4;
  131.     float outerRadius=0.8;
  132.     float scalFac;
  133.  
  134.     rings = 8;
  135.     sides = 10;
  136.     scalFac=1/(outerRadius*2);
  137.  
  138.     glNewList(figure, GL_COMPILE);
  139.     for (i = 0; i < rings; i++) {
  140.         theta1 = (float)i * 2.0 * M_PI / rings;
  141.         theta2 = (float)(i + 1) * 2.0 * M_PI / rings;
  142.         for (j = 0; j < sides; j++) {
  143.             phi1 = (float)j * 2.0 * M_PI / sides;
  144.             phi2 = (float)(j + 1) * 2.0 * M_PI / sides;
  145.  
  146.             v0[0] = cos(theta1) * (outerRadius + innerRadius * cos(phi1));
  147.             v0[1] = -sin(theta1) * (outerRadius + innerRadius * cos(phi1));
  148.             v0[2] = innerRadius * sin(phi1);
  149.  
  150.             v1[0] = cos(theta2) * (outerRadius + innerRadius * cos(phi1));
  151.             v1[1] = -sin(theta2) * (outerRadius + innerRadius * cos(phi1));
  152.             v1[2] = innerRadius * sin(phi1);
  153.             v2[0] = cos(theta2) * (outerRadius + innerRadius * cos(phi2));
  154.             v2[1] = -sin(theta2) * (outerRadius + innerRadius * cos(phi2));
  155.             v2[2] = innerRadius * sin(phi2);
  156.  
  157.             v3[0] = cos(theta1) * (outerRadius + innerRadius * cos(phi2));
  158.             v3[1] = -sin(theta1) * (outerRadius + innerRadius * cos(phi2));
  159.             v3[2] = innerRadius * sin(phi2);
  160.  
  161.             n0[0] = cos(theta1) * (cos(phi1));
  162.             n0[1] = -sin(theta1) * (cos(phi1));
  163.             n0[2] = sin(phi1);
  164.  
  165.             n1[0] = cos(theta2) * (cos(phi1));
  166.             n1[1] = -sin(theta2) * (cos(phi1));
  167.             n1[2] = sin(phi1);
  168.  
  169.             n2[0] = cos(theta2) * (cos(phi2));
  170.             n2[1] = -sin(theta2) * (cos(phi2));
  171.             n2[2] = sin(phi2);
  172.  
  173.             n3[0] = cos(theta1) * (cos(phi2));
  174.             n3[1] = -sin(theta1) * (cos(phi2));
  175.             n3[2] = sin(phi2);
  176.  
  177.             t0[0] = v0[0]*scalFac + 0.5;
  178.             t0[1] = v0[1]*scalFac + 0.5;
  179.             t0[2] = v0[2]*scalFac + 0.5;
  180.  
  181.             t1[0] = v1[0]*scalFac + 0.5;
  182.             t1[1] = v1[1]*scalFac + 0.5;
  183.             t1[2] = v1[2]*scalFac + 0.5;
  184.  
  185.             t2[0] = v2[0]*scalFac + 0.5;
  186.             t2[1] = v2[1]*scalFac + 0.5;
  187.             t2[2] = v2[2]*scalFac + 0.5;
  188.  
  189.             t3[0] = v3[0]*scalFac + 0.5;
  190.             t3[1] = v3[1]*scalFac + 0.5;
  191.             t3[2] = v3[2]*scalFac + 0.5;
  192.  
  193.             glBegin(GL_POLYGON);
  194.                 glNormal3fv(n3); glTexCoord3fv(t3); glVertex3fv(v3);
  195.                 glNormal3fv(n2); glTexCoord3fv(t2); glVertex3fv(v2);
  196.                 glNormal3fv(n1); glTexCoord3fv(t1); glVertex3fv(v1);
  197.                 glNormal3fv(n0); glTexCoord3fv(t0); glVertex3fv(v0);
  198.             glEnd();
  199.         }
  200.     }
  201.     glEndList();
  202. }
  203.  
  204. void create3Dtexture()
  205. {
  206.  int i,j,k;
  207.  unsigned char *vp;
  208.  float vec[3];
  209.  int tmp;
  210.  
  211.  printf("creating 3d textures...\n");
  212.  voxels = (unsigned char  *) malloc((4*tex_width*tex_height*tex_depth));
  213.  vp=voxels;
  214.  for (i=0;i<tex_width;i++){
  215.     vec[0]=i;
  216.     for (j=0;j<tex_height;j++) {
  217.       vec[1]=j;
  218.        for (k=0;k<tex_depth;k++) {
  219.            vec[2]=k;
  220.            tmp=(sin(k*i*j+turbulence(vec,0.01,1))+1)*127.5; 
  221.            *vp++=0;
  222.            *vp++=0;
  223.            *vp++=tmp; 
  224.            *vp++=tmp+128; 
  225.        }
  226.      }
  227.  }
  228.  
  229.  printf("setting up 3d texture...\n");
  230.  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  231.  glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  232.  glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  233.  glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_S,     GL_REPEAT);
  234.  glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_T,     GL_REPEAT);
  235.  glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_R_EXT, GL_REPEAT);
  236.  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
  237.  
  238.  glTexImage3DEXT(GL_TEXTURE_3D_EXT, 0, GL_RGBA,
  239.                     tex_width, tex_height, tex_depth,
  240.                     0, GL_RGBA, GL_UNSIGNED_BYTE, voxels);
  241.  
  242.  printf("finished setting up 3d texture image...\n");
  243. }
  244.  
  245. int isExtSupported(char *ext)
  246. {
  247.     /* routine to find whether a specified OpenGL extension is supported */
  248.  
  249.     char *c;
  250.     int len;
  251.     char *allext = (char *)(glGetString(GL_EXTENSIONS));
  252.  
  253.     len = strlen(ext);
  254.     if (len <= 0) return 0;
  255.  
  256.     c = allext;
  257.     while (c) {
  258.         if (!strncmp(c,ext,len)) return 1;
  259.         c = strchr(c+1,'G');
  260.     }
  261.     return 0;
  262. }
  263.  
  264. void printHelp()
  265. {
  266.   printf("\nUsage: stex3d  <cmd line options>\n"); 
  267.   printf(" cmd line options:\n");
  268.   printf("      -help   print this help!\n");
  269.   printf("     -rgb     RGBA mode. (Default)\n");
  270.   printf("      -ci     Color index mode.\n");
  271.   printf("      -sb     Single buffer mode. (Default)\n");
  272.   printf("      -db     Double buffer mode. \n");
  273.   printf("      -dr     Direct render mode.\n");
  274.   printf("      -ir     Indirect render mode. (Default)\n");
  275.   printf("      -wxxx   Width of the texture (Default=64)\n");
  276.   printf("      -hxxx   Height of the texture (Default=64)\n");
  277.   printf("      -dxxx   Depth of the texture (Default=64)\n");
  278.   printf(" Keyboard Options:\n");
  279.   printf("       1      Object Texture coordinates (Default)\n");
  280.   printf("       2      Eye Texture coordinates \n");
  281.   printf("       x      rotate around x clockwise\n");
  282.   printf("       X      rotate around x counter clockwise\n");
  283.   printf("       y      rotate around y clockwise\n");
  284.   printf("       Y      rotate around y counter clockwise\n");
  285.   printf("       z      rotate around z clockwise\n");
  286.   printf("       Z      rotate around z counter clockwise\n");
  287.   printf("       t      enable 3-D texuring (Default)\n");
  288.   printf("       T      disable 3-D texuring\n");
  289.   printf("       s      smooth shading \n");
  290.   printf("       S      flat shading (Default)\n");
  291. }
  292.  
  293. void setDefaults()
  294. {
  295.  /* visualization defaults */
  296.   rgb = GL_TRUE;
  297.   doubleBuffer = GL_FALSE;
  298.   directRender = GL_TRUE;
  299.   angx=130;
  300.   angy=30;
  301.   angz=0; 
  302.  /* texture values */
  303.  tex_width=64;
  304.  tex_height=64;
  305.  tex_depth=64;
  306. }
  307.  
  308. GLenum parseCmdLine(int argc, char **argv)
  309. {
  310.   GLint i;
  311.  
  312.   setDefaults();
  313.  
  314.   for (i = 1; i < argc; i++) {
  315.       if (strcmp(argv[i], "-ci") == 0) {
  316.           rgb = GL_FALSE;
  317.       } else if (strcmp(argv[i], "-rgb") == 0) {
  318.           rgb = GL_TRUE;
  319.       } else if (strcmp(argv[i], "-sb") == 0) {
  320.           doubleBuffer = GL_FALSE;
  321.       } else if (strcmp(argv[i], "-db") == 0) {
  322.           doubleBuffer = GL_TRUE;
  323.       } else if (strcmp(argv[i], "-dr") == 0) {
  324.           directRender = GL_TRUE;
  325.       } else if (strcmp(argv[i], "-ir") == 0) {
  326.           directRender = GL_FALSE;
  327.       } else if (strstr(argv[i], "-w") == 0) {
  328.           tex_width=atoi((argv[i])+2);
  329.       } else if (strstr(argv[i], "-h") == 0) {
  330.           tex_height=atoi((argv[i])+2);
  331.       } else if (strstr(argv[i], "-d") == 0) {
  332.           tex_depth=atoi((argv[i])+2);
  333.       } else if (strcmp(argv[i], "-help") == 0) {
  334.           printHelp();
  335.           return GL_FALSE;
  336.       } else {
  337.           printf("%s (Bad option).\n", argv[i]);
  338.           printHelp();
  339.           return GL_FALSE;
  340.       }
  341.   }
  342.  if(tex_width==0 || tex_height==0 || tex_depth==0) {
  343.    printf("%s (Bad option).\n", "size parameters can't be 0");
  344.    printHelp();
  345.    return GL_FALSE;
  346.  }
  347.   return GL_TRUE;
  348. }
  349.  
  350. void drawScene()
  351. {
  352.  /* clear background, z buffer etc */
  353.  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  354.  glPushMatrix();
  355.  glRotatef(angx,1.0,0.0,0.0);
  356.  glRotatef(angy,0.0,1.0,0.0);
  357.  glRotatef(angz,0.0,0.0,1.0);
  358.  
  359.  glCallList(figure);     
  360.  glPopMatrix();
  361.  glFlush();
  362.  if(doubleBuffer)
  363.    tkSwapBuffers();
  364.  ;
  365. }
  366.  
  367. void resize(int w, int h)
  368. { 
  369.  glViewport(0, 0, (GLint)w, (GLint)h);
  370.  glMatrixMode(GL_PROJECTION);
  371.  glLoadIdentity();
  372.  glOrtho(-2,2,-2,2,-5,10);
  373.  glMatrixMode(GL_MODELVIEW);
  374.  glLoadIdentity();
  375.  glTranslatef(0,0,-5);
  376. }
  377.  
  378. void cleanEverything()
  379. {
  380. /*  free(voxels); */
  381. }
  382.  
  383. GLenum keyHandler(int key, GLenum mask)
  384. {
  385.  switch(key) {
  386.       case TK_ESCAPE:
  387.    case TK_q:
  388.    case TK_Q: /* quit game. */
  389.           cleanEverything();
  390.            tkQuit();
  391.            break;
  392.    case TK_x:
  393.            angx+=10;
  394.            break;
  395.    case TK_X: 
  396.            angx-=10; 
  397.            break;
  398.    case TK_y:
  399.            angy+=10;
  400.            break;
  401.    case TK_Y: 
  402.            angy-=10; 
  403.            break;
  404.    case TK_z:
  405.            angz+=10;
  406.            break;
  407.    case TK_Z: 
  408.            angz-=10; 
  409.            break;
  410.    case TK_t:
  411.            glEnable(GL_TEXTURE_3D_EXT); 
  412.            break;
  413.    case TK_T:
  414.            glDisable(GL_TEXTURE_3D_EXT);
  415.            break;
  416.    case TK_s:
  417.            glShadeModel(GL_SMOOTH);
  418.            break;
  419.    case TK_S:
  420.            glShadeModel(GL_FLAT);
  421.            break;
  422.    case TK_1:
  423.            glDisable(GL_TEXTURE_GEN_S);
  424.            glDisable(GL_TEXTURE_GEN_T);
  425.            glDisable(GL_TEXTURE_GEN_R);
  426.            break;
  427.    case TK_2:
  428.            glEnable(GL_TEXTURE_GEN_S);
  429.            glEnable(GL_TEXTURE_GEN_T);
  430.            glEnable(GL_TEXTURE_GEN_R);
  431.            break;
  432.    default:
  433.      break;
  434.  }
  435.  return GL_TRUE;
  436. }
  437.  
  438. /*--------------------------------------------------------------------
  439.  noise function over R3 - implemented by a pseudorandom tricubic spline 
  440.               EXCERPTED FROM SIGGRAPH 92, COURSE 23
  441.                         PROCEDURAL MODELING
  442.                              Ken Perlin
  443.                            New York University
  444. ----------------------------------------------------------------------*/
  445.  
  446.  
  447. #define DOT(a,b) (a[0] * b[0] + a[1] * b[1] + a[2] * b[2])
  448. #define B 256
  449. static int p[B + B + 2];
  450. static float g[B + B + 2][3];
  451. #define setup(i,b0,b1,r0,r1) \
  452.         t = vec[i] + 10000.; \
  453.         b0 = ((int)t) & (B-1); \
  454.         b1 = (b0+1) & (B-1); \
  455.         r0 = t - (int)t; \
  456.         r1 = r0 - 1.;
  457.  
  458. float noise3(float vec[3])
  459. {
  460.         int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
  461.         float rx0, rx1, ry0, ry1, rz0, rz1, *q, sx, sy, sz, a, b, c, d, t, u, v;
  462.         register i, j;
  463.  
  464.         setup(0, bx0,bx1, rx0,rx1);
  465.         setup(1, by0,by1, ry0,ry1);
  466.         setup(2, bz0,bz1, rz0,rz1);
  467.  
  468.         i = p[ bx0 ];
  469.         j = p[ bx1 ];
  470.  
  471.         b00 = p[ i + by0 ];
  472.         b10 = p[ j + by0 ];
  473.         b01 = p[ i + by1 ];
  474.         b11 = p[ j + by1 ];
  475.  
  476. #define at(rx,ry,rz) ( rx * q[0] + ry * q[1] + rz * q[2] )
  477. #define surve(t) ( t * t * (3. - 2. * t) )
  478. #define lerp(t, a, b) ( a + t * (b - a) )
  479.  
  480.         sx = surve(rx0);
  481.         sy = surve(ry0);
  482.         sz = surve(rz0);
  483.  
  484.         q = g[ b00 + bz0 ] ; u = at(rx0,ry0,rz0);
  485.         q = g[ b10 + bz0 ] ; v = at(rx1,ry0,rz0);
  486.         a = lerp(sx, u, v);
  487.  
  488.         q = g[ b01 + bz0 ] ; u = at(rx0,ry1,rz0);
  489.         q = g[ b11 + bz0 ] ; v = at(rx1,ry1,rz0);
  490.         b = lerp(sx, u, v);
  491.  
  492.         c = lerp(sy, a, b);          /* interpolate in y at lo x */
  493.  
  494.         q = g[ b00 + bz1 ] ; u = at(rx0,ry0,rz1);
  495.         q = g[ b10 + bz1 ] ; v = at(rx1,ry0,rz1);
  496.         a = lerp(sx, u, v);
  497.  
  498.         q = g[ b01 + bz1 ] ; u = at(rx0,ry1,rz1);
  499.         q = g[ b11 + bz1 ] ; v = at(rx1,ry1,rz1);
  500.         b = lerp(sx, u, v);
  501.  
  502.         d = lerp(sy, a, b);          /* interpolate in y at hi x */
  503.  
  504.         return 1.5 * lerp(sz, c, d); /* interpolate in z */
  505. }
  506.  
  507. void initNoise()
  508. {
  509.         long random();
  510.         int i, j, k;
  511.         float v[3], s;
  512.  
  513. /* Create an array of random gradient vectors uniformly on the unit sphere */
  514.         srandom(1);
  515.         for (i = 0 ; i < B ; i++) {
  516.                 do {                            /* Choose uniformly in a cube */                        for (j=0 ; j<3 ; j++)
  517.                                 v[j] = (float)((random() % (B + B)) - B) / B;
  518.                         s = DOT(v,v);
  519.                 } while (s > 1.0);              /* If not in sphere try again */                s = sqrt(s);
  520.                 for (j = 0 ; j < 3 ; j++)       /* Else normalize */
  521.                         g[i][j] = v[j] / s;
  522.         }
  523.  
  524. /* Create a pseudorandom permutation of [1..B] */
  525.         for (i = 0 ; i < B ; i++)
  526.                 p[i] = i;
  527.         for (i = B ; i > 0 ; i -= 2) {
  528.                 k = p[i];
  529.                 p[i] = p[j = random() % B];
  530.                 p[j] = k;
  531.         }
  532.  
  533. /* Extend g and p arrays to allow for faster indexing */
  534.         for (i = 0 ; i < B + 2 ; i++) {
  535.                 p[B + i] = p[i];
  536.                 for (j = 0 ; j < 3 ; j++)
  537.                         g[B + i][j] = g[i][j];
  538.         }
  539. }
  540.  
  541. float turbulence(float point[3], float lofreq, float hifreq)
  542. {
  543.         float freq, t, p[3];
  544.  
  545.         p[0] = point[0] + 123.456;
  546.         p[1] = point[1];
  547.         p[2] = point[2];
  548.  
  549.         t = 0;
  550.         for (freq = lofreq ; freq < hifreq ; freq *= 2.) {
  551.                 t += fabs(noise3(p)) / freq;
  552.                 p[0] *= 2.;
  553.                 p[1] *= 2.;
  554.                 p[2] *= 2.;
  555.         }
  556.         return t - 0.3; /* readjust to make mean value = 0.0 */
  557. }
  558.  
  559.